Package [root]
Types
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
abstract class AbstractMutableCollection<E> : AbstractCollection<E> , MutableCollection<E>
Content copied to clipboard
Link copied to clipboard
abstract class AbstractMutableList<E> : AbstractMutableCollection<E> , MutableList<E>
Content copied to clipboard
Link copied to clipboard
abstract class AbstractMutableMap<K, V> : AbstractMap<K, V> , MutableMap<K, V>
Content copied to clipboard
Link copied to clipboard
abstract class AbstractMutableSet<E> : AbstractMutableCollection<E> , MutableSet<E>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
open class ArrayList<E> : AbstractMutableList<E> , MutableList<E> , RandomAccess
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Functions
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T, K, V> Array<out T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>
Content copied to clipboard
inline fun <K, V> BooleanArray.associate(transform: (Boolean) -> Pair<K, V>): Map<K, V>
Content copied to clipboard
inline fun <K, V> ByteArray.associate(transform: (Byte) -> Pair<K, V>): Map<K, V>
Content copied to clipboard
inline fun <K, V> CharArray.associate(transform: (Char) -> Pair<K, V>): Map<K, V>
Content copied to clipboard
inline fun <K, V> DoubleArray.associate(transform: (Double) -> Pair<K, V>): Map<K, V>
Content copied to clipboard
inline fun <K, V> FloatArray.associate(transform: (Float) -> Pair<K, V>): Map<K, V>
Content copied to clipboard
inline fun <K, V> IntArray.associate(transform: (Int) -> Pair<K, V>): Map<K, V>
Content copied to clipboard
inline fun <K, V> LongArray.associate(transform: (Long) -> Pair<K, V>): Map<K, V>
Content copied to clipboard
Link copied to clipboard
inline fun <T, K> Array<out T>.associateBy(keySelector: (T) -> K): Map<K, T>
Content copied to clipboard
inline fun <K> BooleanArray.associateBy(keySelector: (Boolean) -> K): Map<K, Boolean>
Content copied to clipboard
inline fun <K> ByteArray.associateBy(keySelector: (Byte) -> K): Map<K, Byte>
Content copied to clipboard
inline fun <K> CharArray.associateBy(keySelector: (Char) -> K): Map<K, Char>
Content copied to clipboard
inline fun <K> DoubleArray.associateBy(keySelector: (Double) -> K): Map<K, Double>
Content copied to clipboard
inline fun <K> FloatArray.associateBy(keySelector: (Float) -> K): Map<K, Float>
Content copied to clipboard
inline fun <K> IntArray.associateBy(keySelector: (Int) -> K): Map<K, Int>
Content copied to clipboard
inline fun <K> LongArray.associateBy(keySelector: (Long) -> K): Map<K, Long>
Content copied to clipboard
inline fun <K> ShortArray.associateBy(keySelector: (Short) -> K): Map<K, Short>
Content copied to clipboard
inline fun <T, K> Iterable<T>.associateBy(keySelector: (T) -> K): Map<K, T>
Content copied to clipboard
inline fun <T, K, V> Array<out T>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>
Content copied to clipboard
inline fun <K, V> BooleanArray.associateBy(keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): Map<K, V>
Content copied to clipboard
inline fun <K, V> ByteArray.associateBy(keySelector: (Byte) -> K, valueTransform: (Byte) -> V): Map<K, V>
Content copied to clipboard
inline fun <K, V> CharArray.associateBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Map<K, V>
Content copied to clipboard
inline fun <K, V> DoubleArray.associateBy(keySelector: (Double) -> K, valueTransform: (Double) -> V): Map<K, V>
Content copied to clipboard
inline fun <K, V> FloatArray.associateBy(keySelector: (Float) -> K, valueTransform: (Float) -> V): Map<K, V>
Content copied to clipboard
inline fun <K, V> IntArray.associateBy(keySelector: (Int) -> K, valueTransform: (Int) -> V): Map<K, V>
Content copied to clipboard
inline fun <K, V> LongArray.associateBy(keySelector: (Long) -> K, valueTransform: (Long) -> V): Map<K, V>
Content copied to clipboard
Link copied to clipboard
inline fun <T, K, M : MutableMap<in K, in T>> Array<out T>.associateByTo(destination: M, keySelector: (T) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, in Boolean>> BooleanArray.associateByTo(destination: M, keySelector: (Boolean) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, in Byte>> ByteArray.associateByTo(destination: M, keySelector: (Byte) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, in Char>> CharArray.associateByTo(destination: M, keySelector: (Char) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, in Double>> DoubleArray.associateByTo(destination: M, keySelector: (Double) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, in Float>> FloatArray.associateByTo(destination: M, keySelector: (Float) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, in Int>> IntArray.associateByTo(destination: M, keySelector: (Int) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, in Long>> LongArray.associateByTo(destination: M, keySelector: (Long) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, in Short>> ShortArray.associateByTo(destination: M, keySelector: (Short) -> K): M
Content copied to clipboard
inline fun <T, K, M : MutableMap<in K, in T>> Iterable<T>.associateByTo(destination: M, keySelector: (T) -> K): M
Content copied to clipboard
inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>.associateByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> BooleanArray.associateByTo( destination: M, keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> ByteArray.associateByTo( destination: M, keySelector: (Byte) -> K, valueTransform: (Byte) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> CharArray.associateByTo( destination: M, keySelector: (Char) -> K, valueTransform: (Char) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> DoubleArray.associateByTo( destination: M, keySelector: (Double) -> K, valueTransform: (Double) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> FloatArray.associateByTo( destination: M, keySelector: (Float) -> K, valueTransform: (Float) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> IntArray.associateByTo( destination: M, keySelector: (Int) -> K, valueTransform: (Int) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> LongArray.associateByTo( destination: M, keySelector: (Long) -> K, valueTransform: (Long) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> ShortArray.associateByTo( destination: M, keySelector: (Short) -> K, valueTransform: (Short) -> V): M
Content copied to clipboard
Link copied to clipboard
inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>.associateTo(destination: M, transform: (T) -> Pair<K, V>): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> BooleanArray.associateTo(destination: M, transform: (Boolean) -> Pair<K, V>): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> ByteArray.associateTo(destination: M, transform: (Byte) -> Pair<K, V>): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> CharArray.associateTo(destination: M, transform: (Char) -> Pair<K, V>): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> DoubleArray.associateTo(destination: M, transform: (Double) -> Pair<K, V>): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> FloatArray.associateTo(destination: M, transform: (Float) -> Pair<K, V>): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> IntArray.associateTo(destination: M, transform: (Int) -> Pair<K, V>): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> LongArray.associateTo(destination: M, transform: (Long) -> Pair<K, V>): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> ShortArray.associateTo(destination: M, transform: (Short) -> Pair<K, V>): M
Content copied to clipboard
Link copied to clipboard
inline fun <K, V> Array<out K>.associateWith(valueSelector: (K) -> V): Map<K, V>
Content copied to clipboard
inline fun <V> BooleanArray.associateWith(valueSelector: (Boolean) -> V): Map<Boolean, V>
Content copied to clipboard
inline fun <V> ByteArray.associateWith(valueSelector: (Byte) -> V): Map<Byte, V>
Content copied to clipboard
inline fun <V> CharArray.associateWith(valueSelector: (Char) -> V): Map<Char, V>
Content copied to clipboard
inline fun <V> DoubleArray.associateWith(valueSelector: (Double) -> V): Map<Double, V>
Content copied to clipboard
inline fun <V> FloatArray.associateWith(valueSelector: (Float) -> V): Map<Float, V>
Content copied to clipboard
inline fun <V> IntArray.associateWith(valueSelector: (Int) -> V): Map<Int, V>
Content copied to clipboard
inline fun <V> LongArray.associateWith(valueSelector: (Long) -> V): Map<Long, V>
Content copied to clipboard
inline fun <V> ShortArray.associateWith(valueSelector: (Short) -> V): Map<Short, V>
Content copied to clipboard
inline fun <V> UByteArray.associateWith(valueSelector: (UByte) -> V): Map<UByte, V>
Content copied to clipboard
inline fun <V> UIntArray.associateWith(valueSelector: (UInt) -> V): Map<UInt, V>
Content copied to clipboard
inline fun <V> ULongArray.associateWith(valueSelector: (ULong) -> V): Map<ULong, V>
Content copied to clipboard
inline fun <V> UShortArray.associateWith(valueSelector: (UShort) -> V): Map<UShort, V>
Content copied to clipboard
Link copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> Array<out K>.associateWithTo(destination: M, valueSelector: (K) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in Boolean, in V>> BooleanArray.associateWithTo(destination: M, valueSelector: (Boolean) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in Byte, in V>> ByteArray.associateWithTo(destination: M, valueSelector: (Byte) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in Char, in V>> CharArray.associateWithTo(destination: M, valueSelector: (Char) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in Double, in V>> DoubleArray.associateWithTo(destination: M, valueSelector: (Double) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in Float, in V>> FloatArray.associateWithTo(destination: M, valueSelector: (Float) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in Int, in V>> IntArray.associateWithTo(destination: M, valueSelector: (Int) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in Long, in V>> LongArray.associateWithTo(destination: M, valueSelector: (Long) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in Short, in V>> ShortArray.associateWithTo(destination: M, valueSelector: (Short) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in UByte, in V>> UByteArray.associateWithTo(destination: M, valueSelector: (UByte) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in UInt, in V>> UIntArray.associateWithTo(destination: M, valueSelector: (UInt) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in ULong, in V>> ULongArray.associateWithTo(destination: M, valueSelector: (ULong) -> V): M
Content copied to clipboard
inline fun <V, M : MutableMap<in UShort, in V>> UShortArray.associateWithTo(destination: M, valueSelector: (UShort) -> V): M
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <T : Comparable<T>> List<T?>.binarySearch(element: T?, fromIndex: Int)
Content copied to clipboard
fun <T> List<T>.binarySearch( element: T, comparator: Comparator<in T>, fromIndex: Int)
Content copied to clipboard
Link copied to clipboard
inline fun <T, K : Comparable<K>> List<T>.binarySearchBy(key: K?, fromIndex: Int)
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T> Collection<T>.containsAll(elements: Collection<T>): Boolean
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.copyInto(destination: Array<T>, destinationOffset: Int)
Content copied to clipboard
inline fun BooleanArray.copyInto(destination: BooleanArray, destinationOffset: Int)
Content copied to clipboard
inline fun ByteArray.copyInto(destination: ByteArray, destinationOffset: Int)
Content copied to clipboard
inline fun CharArray.copyInto(destination: CharArray, destinationOffset: Int)
Content copied to clipboard
inline fun DoubleArray.copyInto(destination: DoubleArray, destinationOffset: Int)
Content copied to clipboard
inline fun FloatArray.copyInto(destination: FloatArray, destinationOffset: Int)
Content copied to clipboard
inline fun IntArray.copyInto(destination: IntArray, destinationOffset: Int)
Content copied to clipboard
inline fun LongArray.copyInto(destination: LongArray, destinationOffset: Int)
Content copied to clipboard
inline fun ShortArray.copyInto(destination: ShortArray, destinationOffset: Int)
Content copied to clipboard
inline fun UByteArray.copyInto(destination: UByteArray, destinationOffset: Int)
Content copied to clipboard
inline fun UIntArray.copyInto(destination: UIntArray, destinationOffset: Int)
Content copied to clipboard
inline fun ULongArray.copyInto(destination: ULongArray, destinationOffset: Int)
Content copied to clipboard
inline fun UShortArray.copyInto(destination: UShortArray, destinationOffset: Int)
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun UByteArray.copyOfRange(fromIndex: Int, toIndex: Int): UByteArray
Content copied to clipboard
inline fun UIntArray.copyOfRange(fromIndex: Int, toIndex: Int): UIntArray
Content copied to clipboard
inline fun ULongArray.copyOfRange(fromIndex: Int, toIndex: Int): ULongArray
Content copied to clipboard
inline fun UShortArray.copyOfRange(fromIndex: Int, toIndex: Int): UShortArray
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <K> BooleanArray.distinctBy(selector: (Boolean) -> K): List<Boolean>
Content copied to clipboard
inline fun <K> DoubleArray.distinctBy(selector: (Double) -> K): List<Double>
Content copied to clipboard
inline fun <K> FloatArray.distinctBy(selector: (Float) -> K): List<Float>
Content copied to clipboard
inline fun <K> ShortArray.distinctBy(selector: (Short) -> K): List<Short>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.dropLastWhile(predicate: (T) -> Boolean): List<T>
Content copied to clipboard
inline fun BooleanArray.dropLastWhile(predicate: (Boolean) -> Boolean): List<Boolean>
Content copied to clipboard
inline fun ByteArray.dropLastWhile(predicate: (Byte) -> Boolean): List<Byte>
Content copied to clipboard
inline fun CharArray.dropLastWhile(predicate: (Char) -> Boolean): List<Char>
Content copied to clipboard
inline fun DoubleArray.dropLastWhile(predicate: (Double) -> Boolean): List<Double>
Content copied to clipboard
inline fun FloatArray.dropLastWhile(predicate: (Float) -> Boolean): List<Float>
Content copied to clipboard
inline fun IntArray.dropLastWhile(predicate: (Int) -> Boolean): List<Int>
Content copied to clipboard
inline fun LongArray.dropLastWhile(predicate: (Long) -> Boolean): List<Long>
Content copied to clipboard
inline fun ShortArray.dropLastWhile(predicate: (Short) -> Boolean): List<Short>
Content copied to clipboard
inline fun UByteArray.dropLastWhile(predicate: (UByte) -> Boolean): List<UByte>
Content copied to clipboard
inline fun UIntArray.dropLastWhile(predicate: (UInt) -> Boolean): List<UInt>
Content copied to clipboard
inline fun ULongArray.dropLastWhile(predicate: (ULong) -> Boolean): List<ULong>
Content copied to clipboard
inline fun UShortArray.dropLastWhile(predicate: (UShort) -> Boolean): List<UShort>
Content copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.dropWhile(predicate: (T) -> Boolean): List<T>
Content copied to clipboard
inline fun BooleanArray.dropWhile(predicate: (Boolean) -> Boolean): List<Boolean>
Content copied to clipboard
inline fun DoubleArray.dropWhile(predicate: (Double) -> Boolean): List<Double>
Content copied to clipboard
inline fun FloatArray.dropWhile(predicate: (Float) -> Boolean): List<Float>
Content copied to clipboard
inline fun ShortArray.dropWhile(predicate: (Short) -> Boolean): List<Short>
Content copied to clipboard
inline fun UByteArray.dropWhile(predicate: (UByte) -> Boolean): List<UByte>
Content copied to clipboard
inline fun ULongArray.dropWhile(predicate: (ULong) -> Boolean): List<ULong>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T
Content copied to clipboard
inline fun BooleanArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Boolean): Boolean
Content copied to clipboard
inline fun ByteArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Byte): Byte
Content copied to clipboard
inline fun CharArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Char): Char
Content copied to clipboard
inline fun DoubleArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Double): Double
Content copied to clipboard
inline fun FloatArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Float): Float
Content copied to clipboard
inline fun IntArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Int): Int
Content copied to clipboard
inline fun LongArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Long): Long
Content copied to clipboard
inline fun ShortArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Short): Short
Content copied to clipboard
inline fun UByteArray.elementAtOrElse(index: Int, defaultValue: (Int) -> UByte): UByte
Content copied to clipboard
inline fun UIntArray.elementAtOrElse(index: Int, defaultValue: (Int) -> UInt): UInt
Content copied to clipboard
inline fun ULongArray.elementAtOrElse(index: Int, defaultValue: (Int) -> ULong): ULong
Content copied to clipboard
inline fun UShortArray.elementAtOrElse(index: Int, defaultValue: (Int) -> UShort): UShort
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun BooleanArray.filter(predicate: (Boolean) -> Boolean): List<Boolean>
Content copied to clipboard
inline fun DoubleArray.filter(predicate: (Double) -> Boolean): List<Double>
Content copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>
Content copied to clipboard
inline fun BooleanArray.filterIndexed(predicate: (index: Int, Boolean) -> Boolean): List<Boolean>
Content copied to clipboard
inline fun ByteArray.filterIndexed(predicate: (index: Int, Byte) -> Boolean): List<Byte>
Content copied to clipboard
inline fun CharArray.filterIndexed(predicate: (index: Int, Char) -> Boolean): List<Char>
Content copied to clipboard
inline fun DoubleArray.filterIndexed(predicate: (index: Int, Double) -> Boolean): List<Double>
Content copied to clipboard
inline fun FloatArray.filterIndexed(predicate: (index: Int, Float) -> Boolean): List<Float>
Content copied to clipboard
inline fun IntArray.filterIndexed(predicate: (index: Int, Int) -> Boolean): List<Int>
Content copied to clipboard
inline fun LongArray.filterIndexed(predicate: (index: Int, Long) -> Boolean): List<Long>
Content copied to clipboard
inline fun ShortArray.filterIndexed(predicate: (index: Int, Short) -> Boolean): List<Short>
Content copied to clipboard
inline fun UByteArray.filterIndexed(predicate: (index: Int, UByte) -> Boolean): List<UByte>
Content copied to clipboard
inline fun UIntArray.filterIndexed(predicate: (index: Int, UInt) -> Boolean): List<UInt>
Content copied to clipboard
inline fun ULongArray.filterIndexed(predicate: (index: Int, ULong) -> Boolean): List<ULong>
Content copied to clipboard
inline fun UShortArray.filterIndexed(predicate: (index: Int, UShort) -> Boolean): List<UShort>
Content copied to clipboard
Link copied to clipboard
inline fun <T, C : MutableCollection<in T>> Array<out T>.filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterIndexedTo(destination: C, predicate: (index: Int, Boolean) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Byte>> ByteArray.filterIndexedTo(destination: C, predicate: (index: Int, Byte) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Char>> CharArray.filterIndexedTo(destination: C, predicate: (index: Int, Char) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Double>> DoubleArray.filterIndexedTo(destination: C, predicate: (index: Int, Double) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Float>> FloatArray.filterIndexedTo(destination: C, predicate: (index: Int, Float) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Int>> IntArray.filterIndexedTo(destination: C, predicate: (index: Int, Int) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Long>> LongArray.filterIndexedTo(destination: C, predicate: (index: Int, Long) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Short>> ShortArray.filterIndexedTo(destination: C, predicate: (index: Int, Short) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in UByte>> UByteArray.filterIndexedTo(destination: C, predicate: (index: Int, UByte) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in UInt>> UIntArray.filterIndexedTo(destination: C, predicate: (index: Int, UInt) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in ULong>> ULongArray.filterIndexedTo(destination: C, predicate: (index: Int, ULong) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in UShort>> UShortArray.filterIndexedTo(destination: C, predicate: (index: Int, UShort) -> Boolean): C
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <R, C : MutableCollection<in R>> Array<*>.filterIsInstanceTo(destination: C): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C
Content copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.filterNot(predicate: (T) -> Boolean): List<T>
Content copied to clipboard
inline fun BooleanArray.filterNot(predicate: (Boolean) -> Boolean): List<Boolean>
Content copied to clipboard
inline fun DoubleArray.filterNot(predicate: (Double) -> Boolean): List<Double>
Content copied to clipboard
inline fun FloatArray.filterNot(predicate: (Float) -> Boolean): List<Float>
Content copied to clipboard
inline fun ShortArray.filterNot(predicate: (Short) -> Boolean): List<Short>
Content copied to clipboard
inline fun UByteArray.filterNot(predicate: (UByte) -> Boolean): List<UByte>
Content copied to clipboard
inline fun ULongArray.filterNot(predicate: (ULong) -> Boolean): List<ULong>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <C : MutableCollection<in T>, T : Any> Array<out T?>.filterNotNullTo(destination: C): C
Content copied to clipboard
fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(destination: C): C
Content copied to clipboard
Link copied to clipboard
inline fun <T, C : MutableCollection<in T>> Array<out T>.filterNotTo(destination: C, predicate: (T) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterNotTo(destination: C, predicate: (Boolean) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Byte>> ByteArray.filterNotTo(destination: C, predicate: (Byte) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Char>> CharArray.filterNotTo(destination: C, predicate: (Char) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Double>> DoubleArray.filterNotTo(destination: C, predicate: (Double) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Float>> FloatArray.filterNotTo(destination: C, predicate: (Float) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Int>> IntArray.filterNotTo(destination: C, predicate: (Int) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Long>> LongArray.filterNotTo(destination: C, predicate: (Long) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Short>> ShortArray.filterNotTo(destination: C, predicate: (Short) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in UByte>> UByteArray.filterNotTo(destination: C, predicate: (UByte) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in UInt>> UIntArray.filterNotTo(destination: C, predicate: (UInt) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in ULong>> ULongArray.filterNotTo(destination: C, predicate: (ULong) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in UShort>> UShortArray.filterNotTo(destination: C, predicate: (UShort) -> Boolean): C
Content copied to clipboard
Link copied to clipboard
inline fun <T, C : MutableCollection<in T>> Array<out T>.filterTo(destination: C, predicate: (T) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterTo(destination: C, predicate: (Boolean) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Byte>> ByteArray.filterTo(destination: C, predicate: (Byte) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Char>> CharArray.filterTo(destination: C, predicate: (Char) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Double>> DoubleArray.filterTo(destination: C, predicate: (Double) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Float>> FloatArray.filterTo(destination: C, predicate: (Float) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Int>> IntArray.filterTo(destination: C, predicate: (Int) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Long>> LongArray.filterTo(destination: C, predicate: (Long) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in Short>> ShortArray.filterTo(destination: C, predicate: (Short) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in UByte>> UByteArray.filterTo(destination: C, predicate: (UByte) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in UInt>> UIntArray.filterTo(destination: C, predicate: (UInt) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in ULong>> ULongArray.filterTo(destination: C, predicate: (ULong) -> Boolean): C
Content copied to clipboard
inline fun <C : MutableCollection<in UShort>> UShortArray.filterTo(destination: C, predicate: (UShort) -> Boolean): C
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun BooleanArray.findLast(predicate: (Boolean) -> Boolean): Boolean?
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun BooleanArray.firstOrNull(predicate: (Boolean) -> Boolean): Boolean?
Content copied to clipboard
inline fun DoubleArray.firstOrNull(predicate: (Double) -> Boolean): Double?
Content copied to clipboard
inline fun UShortArray.firstOrNull(predicate: (UShort) -> Boolean): UShort?
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.flatMap(transform: (T) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <T, R> Array<out T>.flatMap(transform: (T) -> Sequence<R>): List<R>
Content copied to clipboard
inline fun <R> BooleanArray.flatMap(transform: (Boolean) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> ByteArray.flatMap(transform: (Byte) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> CharArray.flatMap(transform: (Char) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> DoubleArray.flatMap(transform: (Double) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> FloatArray.flatMap(transform: (Float) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> IntArray.flatMap(transform: (Int) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> LongArray.flatMap(transform: (Long) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> ShortArray.flatMap(transform: (Short) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> UByteArray.flatMap(transform: (UByte) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> UIntArray.flatMap(transform: (UInt) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> ULongArray.flatMap(transform: (ULong) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> UShortArray.flatMap(transform: (UShort) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Sequence<R>): List<R>
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.flatMapIndexed(transform: (index: Int, T) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <T, R> Array<out T>.flatMapIndexed(transform: (index: Int, T) -> Sequence<R>): List<R>
Content copied to clipboard
inline fun <R> BooleanArray.flatMapIndexed(transform: (index: Int, Boolean) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> ByteArray.flatMapIndexed(transform: (index: Int, Byte) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> CharArray.flatMapIndexed(transform: (index: Int, Char) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> DoubleArray.flatMapIndexed(transform: (index: Int, Double) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> FloatArray.flatMapIndexed(transform: (index: Int, Float) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> IntArray.flatMapIndexed(transform: (index: Int, Int) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> LongArray.flatMapIndexed(transform: (index: Int, Long) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> ShortArray.flatMapIndexed(transform: (index: Int, Short) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> UByteArray.flatMapIndexed(transform: (index: Int, UByte) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> UIntArray.flatMapIndexed(transform: (index: Int, UInt) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> ULongArray.flatMapIndexed(transform: (index: Int, ULong) -> Iterable<R>): List<R>
Content copied to clipboard
inline fun <R> UShortArray.flatMapIndexed(transform: (index: Int, UShort) -> Iterable<R>): List<R>
Content copied to clipboard
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Iterable<R>): C
Content copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Sequence<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> BooleanArray.flatMapIndexedTo(destination: C, transform: (index: Int, Boolean) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ByteArray.flatMapIndexedTo(destination: C, transform: (index: Int, Byte) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> CharArray.flatMapIndexedTo(destination: C, transform: (index: Int, Char) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> DoubleArray.flatMapIndexedTo(destination: C, transform: (index: Int, Double) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> FloatArray.flatMapIndexedTo(destination: C, transform: (index: Int, Float) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> IntArray.flatMapIndexedTo(destination: C, transform: (index: Int, Int) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> LongArray.flatMapIndexedTo(destination: C, transform: (index: Int, Long) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ShortArray.flatMapIndexedTo(destination: C, transform: (index: Int, Short) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UByteArray.flatMapIndexedTo(destination: C, transform: (index: Int, UByte) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UIntArray.flatMapIndexedTo(destination: C, transform: (index: Int, UInt) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ULongArray.flatMapIndexedTo(destination: C, transform: (index: Int, ULong) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UShortArray.flatMapIndexedTo(destination: C, transform: (index: Int, UShort) -> Iterable<R>): C
Content copied to clipboard
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C
Content copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(destination: C, transform: (T) -> Sequence<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> BooleanArray.flatMapTo(destination: C, transform: (Boolean) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ByteArray.flatMapTo(destination: C, transform: (Byte) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> CharArray.flatMapTo(destination: C, transform: (Char) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> DoubleArray.flatMapTo(destination: C, transform: (Double) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> FloatArray.flatMapTo(destination: C, transform: (Float) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> IntArray.flatMapTo(destination: C, transform: (Int) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> LongArray.flatMapTo(destination: C, transform: (Long) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ShortArray.flatMapTo(destination: C, transform: (Short) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UByteArray.flatMapTo(destination: C, transform: (UByte) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UIntArray.flatMapTo(destination: C, transform: (UInt) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ULongArray.flatMapTo(destination: C, transform: (ULong) -> Iterable<R>): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UShortArray.flatMapTo(destination: C, transform: (UShort) -> Iterable<R>): C
Content copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C
Content copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Sequence<R>): C
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.fold(initial: R, operation: (acc: R, T) -> R): R
Content copied to clipboard
inline fun <R> BooleanArray.fold(initial: R, operation: (acc: R, Boolean) -> R): R
Content copied to clipboard
inline fun <R> ByteArray.fold(initial: R, operation: (acc: R, Byte) -> R): R
Content copied to clipboard
inline fun <R> CharArray.fold(initial: R, operation: (acc: R, Char) -> R): R
Content copied to clipboard
inline fun <R> DoubleArray.fold(initial: R, operation: (acc: R, Double) -> R): R
Content copied to clipboard
inline fun <R> FloatArray.fold(initial: R, operation: (acc: R, Float) -> R): R
Content copied to clipboard
inline fun <R> IntArray.fold(initial: R, operation: (acc: R, Int) -> R): R
Content copied to clipboard
inline fun <R> LongArray.fold(initial: R, operation: (acc: R, Long) -> R): R
Content copied to clipboard
inline fun <R> ShortArray.fold(initial: R, operation: (acc: R, Short) -> R): R
Content copied to clipboard
inline fun <R> UByteArray.fold(initial: R, operation: (acc: R, UByte) -> R): R
Content copied to clipboard
inline fun <R> UIntArray.fold(initial: R, operation: (acc: R, UInt) -> R): R
Content copied to clipboard
inline fun <R> ULongArray.fold(initial: R, operation: (acc: R, ULong) -> R): R
Content copied to clipboard
inline fun <R> UShortArray.fold(initial: R, operation: (acc: R, UShort) -> R): R
Content copied to clipboard
inline fun <T, K, R> Grouping<T, K>.fold(initialValue: R, operation: (accumulator: R, element: T) -> R): Map<K, R>
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R
Content copied to clipboard
inline fun <R> BooleanArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): R
Content copied to clipboard
inline fun <R> ByteArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): R
Content copied to clipboard
inline fun <R> CharArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): R
Content copied to clipboard
inline fun <R> DoubleArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): R
Content copied to clipboard
inline fun <R> FloatArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): R
Content copied to clipboard
inline fun <R> IntArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): R
Content copied to clipboard
inline fun <R> LongArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): R
Content copied to clipboard
inline fun <R> ShortArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): R
Content copied to clipboard
inline fun <R> UByteArray.foldIndexed(initial: R, operation: (index: Int, acc: R, UByte) -> R): R
Content copied to clipboard
inline fun <R> UIntArray.foldIndexed(initial: R, operation: (index: Int, acc: R, UInt) -> R): R
Content copied to clipboard
inline fun <R> ULongArray.foldIndexed(initial: R, operation: (index: Int, acc: R, ULong) -> R): R
Content copied to clipboard
inline fun <R> UShortArray.foldIndexed(initial: R, operation: (index: Int, acc: R, UShort) -> R): R
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.foldRight(initial: R, operation: (T, acc: R) -> R): R
Content copied to clipboard
inline fun <R> BooleanArray.foldRight(initial: R, operation: (Boolean, acc: R) -> R): R
Content copied to clipboard
inline fun <R> ByteArray.foldRight(initial: R, operation: (Byte, acc: R) -> R): R
Content copied to clipboard
inline fun <R> CharArray.foldRight(initial: R, operation: (Char, acc: R) -> R): R
Content copied to clipboard
inline fun <R> DoubleArray.foldRight(initial: R, operation: (Double, acc: R) -> R): R
Content copied to clipboard
inline fun <R> FloatArray.foldRight(initial: R, operation: (Float, acc: R) -> R): R
Content copied to clipboard
inline fun <R> IntArray.foldRight(initial: R, operation: (Int, acc: R) -> R): R
Content copied to clipboard
inline fun <R> LongArray.foldRight(initial: R, operation: (Long, acc: R) -> R): R
Content copied to clipboard
inline fun <R> ShortArray.foldRight(initial: R, operation: (Short, acc: R) -> R): R
Content copied to clipboard
inline fun <R> UByteArray.foldRight(initial: R, operation: (UByte, acc: R) -> R): R
Content copied to clipboard
inline fun <R> UIntArray.foldRight(initial: R, operation: (UInt, acc: R) -> R): R
Content copied to clipboard
inline fun <R> ULongArray.foldRight(initial: R, operation: (ULong, acc: R) -> R): R
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R
Content copied to clipboard
inline fun <R> BooleanArray.foldRightIndexed(initial: R, operation: (index: Int, Boolean, acc: R) -> R): R
Content copied to clipboard
inline fun <R> ByteArray.foldRightIndexed(initial: R, operation: (index: Int, Byte, acc: R) -> R): R
Content copied to clipboard
inline fun <R> CharArray.foldRightIndexed(initial: R, operation: (index: Int, Char, acc: R) -> R): R
Content copied to clipboard
inline fun <R> DoubleArray.foldRightIndexed(initial: R, operation: (index: Int, Double, acc: R) -> R): R
Content copied to clipboard
inline fun <R> FloatArray.foldRightIndexed(initial: R, operation: (index: Int, Float, acc: R) -> R): R
Content copied to clipboard
inline fun <R> IntArray.foldRightIndexed(initial: R, operation: (index: Int, Int, acc: R) -> R): R
Content copied to clipboard
inline fun <R> LongArray.foldRightIndexed(initial: R, operation: (index: Int, Long, acc: R) -> R): R
Content copied to clipboard
inline fun <R> ShortArray.foldRightIndexed(initial: R, operation: (index: Int, Short, acc: R) -> R): R
Content copied to clipboard
inline fun <R> UByteArray.foldRightIndexed(initial: R, operation: (index: Int, UByte, acc: R) -> R): R
Content copied to clipboard
inline fun <R> UIntArray.foldRightIndexed(initial: R, operation: (index: Int, UInt, acc: R) -> R): R
Content copied to clipboard
inline fun <R> ULongArray.foldRightIndexed(initial: R, operation: (index: Int, ULong, acc: R) -> R): R
Content copied to clipboard
inline fun <R> UShortArray.foldRightIndexed(initial: R, operation: (index: Int, UShort, acc: R) -> R): R
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.forEachIndexed(action: (index: Int, T) -> Unit)
Content copied to clipboard
inline fun BooleanArray.forEachIndexed(action: (index: Int, Boolean) -> Unit)
Content copied to clipboard
inline fun DoubleArray.forEachIndexed(action: (index: Int, Double) -> Unit)
Content copied to clipboard
inline fun FloatArray.forEachIndexed(action: (index: Int, Float) -> Unit)
Content copied to clipboard
inline fun ShortArray.forEachIndexed(action: (index: Int, Short) -> Unit)
Content copied to clipboard
inline fun UByteArray.forEachIndexed(action: (index: Int, UByte) -> Unit)
Content copied to clipboard
inline fun ULongArray.forEachIndexed(action: (index: Int, ULong) -> Unit)
Content copied to clipboard
inline fun UShortArray.forEachIndexed(action: (index: Int, UShort) -> Unit)
Content copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.getOrElse(index: Int, defaultValue: (Int) -> T): T
Content copied to clipboard
inline fun BooleanArray.getOrElse(index: Int, defaultValue: (Int) -> Boolean): Boolean
Content copied to clipboard
inline fun ByteArray.getOrElse(index: Int, defaultValue: (Int) -> Byte): Byte
Content copied to clipboard
inline fun CharArray.getOrElse(index: Int, defaultValue: (Int) -> Char): Char
Content copied to clipboard
inline fun DoubleArray.getOrElse(index: Int, defaultValue: (Int) -> Double): Double
Content copied to clipboard
inline fun FloatArray.getOrElse(index: Int, defaultValue: (Int) -> Float): Float
Content copied to clipboard
inline fun IntArray.getOrElse(index: Int, defaultValue: (Int) -> Int): Int
Content copied to clipboard
inline fun LongArray.getOrElse(index: Int, defaultValue: (Int) -> Long): Long
Content copied to clipboard
inline fun ShortArray.getOrElse(index: Int, defaultValue: (Int) -> Short): Short
Content copied to clipboard
inline fun UByteArray.getOrElse(index: Int, defaultValue: (Int) -> UByte): UByte
Content copied to clipboard
inline fun UIntArray.getOrElse(index: Int, defaultValue: (Int) -> UInt): UInt
Content copied to clipboard
inline fun ULongArray.getOrElse(index: Int, defaultValue: (Int) -> ULong): ULong
Content copied to clipboard
inline fun UShortArray.getOrElse(index: Int, defaultValue: (Int) -> UShort): UShort
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T, K> Array<out T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>
Content copied to clipboard
inline fun <K> BooleanArray.groupBy(keySelector: (Boolean) -> K): Map<K, List<Boolean>>
Content copied to clipboard
inline fun <K> ByteArray.groupBy(keySelector: (Byte) -> K): Map<K, List<Byte>>
Content copied to clipboard
inline fun <K> CharArray.groupBy(keySelector: (Char) -> K): Map<K, List<Char>>
Content copied to clipboard
inline fun <K> DoubleArray.groupBy(keySelector: (Double) -> K): Map<K, List<Double>>
Content copied to clipboard
inline fun <K> FloatArray.groupBy(keySelector: (Float) -> K): Map<K, List<Float>>
Content copied to clipboard
inline fun <K> IntArray.groupBy(keySelector: (Int) -> K): Map<K, List<Int>>
Content copied to clipboard
inline fun <K> LongArray.groupBy(keySelector: (Long) -> K): Map<K, List<Long>>
Content copied to clipboard
inline fun <K> ShortArray.groupBy(keySelector: (Short) -> K): Map<K, List<Short>>
Content copied to clipboard
inline fun <K> UByteArray.groupBy(keySelector: (UByte) -> K): Map<K, List<UByte>>
Content copied to clipboard
inline fun <K> UIntArray.groupBy(keySelector: (UInt) -> K): Map<K, List<UInt>>
Content copied to clipboard
inline fun <K> ULongArray.groupBy(keySelector: (ULong) -> K): Map<K, List<ULong>>
Content copied to clipboard
inline fun <K> UShortArray.groupBy(keySelector: (UShort) -> K): Map<K, List<UShort>>
Content copied to clipboard
inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>
Content copied to clipboard
inline fun <T, K, V> Array<out T>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> BooleanArray.groupBy(keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> ByteArray.groupBy(keySelector: (Byte) -> K, valueTransform: (Byte) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> CharArray.groupBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> DoubleArray.groupBy(keySelector: (Double) -> K, valueTransform: (Double) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> FloatArray.groupBy(keySelector: (Float) -> K, valueTransform: (Float) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> IntArray.groupBy(keySelector: (Int) -> K, valueTransform: (Int) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> LongArray.groupBy(keySelector: (Long) -> K, valueTransform: (Long) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> ShortArray.groupBy(keySelector: (Short) -> K, valueTransform: (Short) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> UByteArray.groupBy(keySelector: (UByte) -> K, valueTransform: (UByte) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> UIntArray.groupBy(keySelector: (UInt) -> K, valueTransform: (UInt) -> V): Map<K, List<V>>
Content copied to clipboard
inline fun <K, V> ULongArray.groupBy(keySelector: (ULong) -> K, valueTransform: (ULong) -> V): Map<K, List<V>>
Content copied to clipboard
Link copied to clipboard
inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Array<out T>.groupByTo(destination: M, keySelector: (T) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<Boolean>>> BooleanArray.groupByTo(destination: M, keySelector: (Boolean) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<Byte>>> ByteArray.groupByTo(destination: M, keySelector: (Byte) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<Char>>> CharArray.groupByTo(destination: M, keySelector: (Char) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<Double>>> DoubleArray.groupByTo(destination: M, keySelector: (Double) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<Float>>> FloatArray.groupByTo(destination: M, keySelector: (Float) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<Int>>> IntArray.groupByTo(destination: M, keySelector: (Int) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<Long>>> LongArray.groupByTo(destination: M, keySelector: (Long) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<Short>>> ShortArray.groupByTo(destination: M, keySelector: (Short) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<UByte>>> UByteArray.groupByTo(destination: M, keySelector: (UByte) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<UInt>>> UIntArray.groupByTo(destination: M, keySelector: (UInt) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<ULong>>> ULongArray.groupByTo(destination: M, keySelector: (ULong) -> K): M
Content copied to clipboard
inline fun <K, M : MutableMap<in K, MutableList<UShort>>> UShortArray.groupByTo(destination: M, keySelector: (UShort) -> K): M
Content copied to clipboard
inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo(destination: M, keySelector: (T) -> K): M
Content copied to clipboard
inline fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Array<out T>.groupByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> BooleanArray.groupByTo( destination: M, keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ByteArray.groupByTo( destination: M, keySelector: (Byte) -> K, valueTransform: (Byte) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> CharArray.groupByTo( destination: M, keySelector: (Char) -> K, valueTransform: (Char) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> DoubleArray.groupByTo( destination: M, keySelector: (Double) -> K, valueTransform: (Double) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> FloatArray.groupByTo( destination: M, keySelector: (Float) -> K, valueTransform: (Float) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> IntArray.groupByTo( destination: M, keySelector: (Int) -> K, valueTransform: (Int) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> LongArray.groupByTo( destination: M, keySelector: (Long) -> K, valueTransform: (Long) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ShortArray.groupByTo( destination: M, keySelector: (Short) -> K, valueTransform: (Short) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> UByteArray.groupByTo( destination: M, keySelector: (UByte) -> K, valueTransform: (UByte) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> UIntArray.groupByTo( destination: M, keySelector: (UInt) -> K, valueTransform: (UInt) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ULongArray.groupByTo( destination: M, keySelector: (ULong) -> K, valueTransform: (ULong) -> V): M
Content copied to clipboard
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> UShortArray.groupByTo( destination: M, keySelector: (UShort) -> K, valueTransform: (UShort) -> V): M
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun BooleanArray.indexOfFirst(predicate: (Boolean) -> Boolean): Int
Content copied to clipboard
Link copied to clipboard
inline fun BooleanArray.indexOfLast(predicate: (Boolean) -> Boolean): Int
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <T, A : Appendable> Array<out T>.joinTo(buffer: A, separator: CharSequence)
Content copied to clipboard
fun <A : Appendable> BooleanArray.joinTo(buffer: A, separator: CharSequence)
Content copied to clipboard
fun <A : Appendable> ByteArray.joinTo(buffer: A, separator: CharSequence)
Content copied to clipboard
fun <A : Appendable> CharArray.joinTo(buffer: A, separator: CharSequence)
Content copied to clipboard
fun <A : Appendable> DoubleArray.joinTo(buffer: A, separator: CharSequence)
Content copied to clipboard
fun <A : Appendable> FloatArray.joinTo(buffer: A, separator: CharSequence)
Content copied to clipboard
fun <A : Appendable> LongArray.joinTo(buffer: A, separator: CharSequence)
Content copied to clipboard
fun <A : Appendable> ShortArray.joinTo(buffer: A, separator: CharSequence)
Content copied to clipboard
fun <T, A : Appendable> Iterable<T>.joinTo(buffer: A, separator: CharSequence)
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun BooleanArray.lastOrNull(predicate: (Boolean) -> Boolean): Boolean?
Content copied to clipboard
inline fun DoubleArray.lastOrNull(predicate: (Double) -> Boolean): Double?
Content copied to clipboard
inline fun UShortArray.lastOrNull(predicate: (UShort) -> Boolean): UShort?
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <V> linkedStringMapOf(vararg pairs: Pair<String, V>): LinkedHashMap<String, V>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.mapIndexed(transform: (index: Int, T) -> R): List<R>
Content copied to clipboard
inline fun <R> BooleanArray.mapIndexed(transform: (index: Int, Boolean) -> R): List<R>
Content copied to clipboard
inline fun <R> ByteArray.mapIndexed(transform: (index: Int, Byte) -> R): List<R>
Content copied to clipboard
inline fun <R> CharArray.mapIndexed(transform: (index: Int, Char) -> R): List<R>
Content copied to clipboard
inline fun <R> DoubleArray.mapIndexed(transform: (index: Int, Double) -> R): List<R>
Content copied to clipboard
inline fun <R> FloatArray.mapIndexed(transform: (index: Int, Float) -> R): List<R>
Content copied to clipboard
inline fun <R> IntArray.mapIndexed(transform: (index: Int, Int) -> R): List<R>
Content copied to clipboard
inline fun <R> LongArray.mapIndexed(transform: (index: Int, Long) -> R): List<R>
Content copied to clipboard
inline fun <R> ShortArray.mapIndexed(transform: (index: Int, Short) -> R): List<R>
Content copied to clipboard
inline fun <R> UByteArray.mapIndexed(transform: (index: Int, UByte) -> R): List<R>
Content copied to clipboard
inline fun <R> UIntArray.mapIndexed(transform: (index: Int, UInt) -> R): List<R>
Content copied to clipboard
inline fun <R> ULongArray.mapIndexed(transform: (index: Int, ULong) -> R): List<R>
Content copied to clipboard
inline fun <R> UShortArray.mapIndexed(transform: (index: Int, UShort) -> R): List<R>
Content copied to clipboard
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> BooleanArray.mapIndexedTo(destination: C, transform: (index: Int, Boolean) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ByteArray.mapIndexedTo(destination: C, transform: (index: Int, Byte) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> CharArray.mapIndexedTo(destination: C, transform: (index: Int, Char) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> DoubleArray.mapIndexedTo(destination: C, transform: (index: Int, Double) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> FloatArray.mapIndexedTo(destination: C, transform: (index: Int, Float) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> IntArray.mapIndexedTo(destination: C, transform: (index: Int, Int) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> LongArray.mapIndexedTo(destination: C, transform: (index: Int, Long) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ShortArray.mapIndexedTo(destination: C, transform: (index: Int, Short) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UByteArray.mapIndexedTo(destination: C, transform: (index: Int, UByte) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UIntArray.mapIndexedTo(destination: C, transform: (index: Int, UInt) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ULongArray.mapIndexedTo(destination: C, transform: (index: Int, ULong) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UShortArray.mapIndexedTo(destination: C, transform: (index: Int, UShort) -> R): C
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.mapTo(destination: C, transform: (T) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> BooleanArray.mapTo(destination: C, transform: (Boolean) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ByteArray.mapTo(destination: C, transform: (Byte) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> CharArray.mapTo(destination: C, transform: (Char) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> DoubleArray.mapTo(destination: C, transform: (Double) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> FloatArray.mapTo(destination: C, transform: (Float) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> IntArray.mapTo(destination: C, transform: (Int) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> LongArray.mapTo(destination: C, transform: (Long) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ShortArray.mapTo(destination: C, transform: (Short) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UByteArray.mapTo(destination: C, transform: (UByte) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UIntArray.mapTo(destination: C, transform: (UInt) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> ULongArray.mapTo(destination: C, transform: (ULong) -> R): C
Content copied to clipboard
inline fun <R, C : MutableCollection<in R>> UShortArray.mapTo(destination: C, transform: (UShort) -> R): C
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.maxBy(selector: (T) -> R): T
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.maxBy(selector: (Boolean) -> R): Boolean
Content copied to clipboard
inline fun <R : Comparable<R>> ByteArray.maxBy(selector: (Byte) -> R): Byte
Content copied to clipboard
inline fun <R : Comparable<R>> CharArray.maxBy(selector: (Char) -> R): Char
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.maxBy(selector: (Double) -> R): Double
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.maxBy(selector: (Float) -> R): Float
Content copied to clipboard
inline fun <R : Comparable<R>> LongArray.maxBy(selector: (Long) -> R): Long
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.maxBy(selector: (Short) -> R): Short
Content copied to clipboard
inline fun <R : Comparable<R>> UByteArray.maxBy(selector: (UByte) -> R): UByte
Content copied to clipboard
inline fun <R : Comparable<R>> UIntArray.maxBy(selector: (UInt) -> R): UInt
Content copied to clipboard
inline fun <R : Comparable<R>> ULongArray.maxBy(selector: (ULong) -> R): ULong
Content copied to clipboard
inline fun <R : Comparable<R>> UShortArray.maxBy(selector: (UShort) -> R): UShort
Content copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.maxByOrNull(selector: (T) -> R): T?
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.maxByOrNull(selector: (Boolean) -> R): Boolean?
Content copied to clipboard
inline fun <R : Comparable<R>> ByteArray.maxByOrNull(selector: (Byte) -> R): Byte?
Content copied to clipboard
inline fun <R : Comparable<R>> CharArray.maxByOrNull(selector: (Char) -> R): Char?
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.maxByOrNull(selector: (Double) -> R): Double?
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.maxByOrNull(selector: (Float) -> R): Float?
Content copied to clipboard
inline fun <R : Comparable<R>> IntArray.maxByOrNull(selector: (Int) -> R): Int?
Content copied to clipboard
inline fun <R : Comparable<R>> LongArray.maxByOrNull(selector: (Long) -> R): Long?
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.maxByOrNull(selector: (Short) -> R): Short?
Content copied to clipboard
inline fun <R : Comparable<R>> UByteArray.maxByOrNull(selector: (UByte) -> R): UByte?
Content copied to clipboard
inline fun <R : Comparable<R>> UIntArray.maxByOrNull(selector: (UInt) -> R): UInt?
Content copied to clipboard
inline fun <R : Comparable<R>> ULongArray.maxByOrNull(selector: (ULong) -> R): ULong?
Content copied to clipboard
inline fun <R : Comparable<R>> UShortArray.maxByOrNull(selector: (UShort) -> R): UShort?
Content copied to clipboard
inline fun <T, R : Comparable<R>> Iterable<T>.maxByOrNull(selector: (T) -> R): T?
Content copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.maxOf(selector: (T) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.maxOf(selector: (Boolean) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.maxOf(selector: (Double) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.maxOf(selector: (Float) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.maxOf(selector: (Short) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> UByteArray.maxOf(selector: (UByte) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> ULongArray.maxOf(selector: (ULong) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> UShortArray.maxOf(selector: (UShort) -> R): R
Content copied to clipboard
inline fun <T, R : Comparable<R>> Iterable<T>.maxOf(selector: (T) -> R): R
Content copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> R): R
Content copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.maxOfOrNull(selector: (T) -> R): R?
Content copied to clipboard
inline fun <T> Array<out T>.maxOfOrNull(selector: (T) -> Double): Double?
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.maxOfOrNull(selector: (Boolean) -> R): R?
Content copied to clipboard
inline fun BooleanArray.maxOfOrNull(selector: (Boolean) -> Double): Double?
Content copied to clipboard
inline fun BooleanArray.maxOfOrNull(selector: (Boolean) -> Float): Float?
Content copied to clipboard
inline fun <R : Comparable<R>> ByteArray.maxOfOrNull(selector: (Byte) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> CharArray.maxOfOrNull(selector: (Char) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.maxOfOrNull(selector: (Double) -> R): R?
Content copied to clipboard
inline fun DoubleArray.maxOfOrNull(selector: (Double) -> Double): Double?
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.maxOfOrNull(selector: (Float) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> IntArray.maxOfOrNull(selector: (Int) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> LongArray.maxOfOrNull(selector: (Long) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.maxOfOrNull(selector: (Short) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> UByteArray.maxOfOrNull(selector: (UByte) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> UIntArray.maxOfOrNull(selector: (UInt) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> ULongArray.maxOfOrNull(selector: (ULong) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> UShortArray.maxOfOrNull(selector: (UShort) -> R): R?
Content copied to clipboard
inline fun UShortArray.maxOfOrNull(selector: (UShort) -> Double): Double?
Content copied to clipboard
inline fun <T, R : Comparable<R>> Iterable<T>.maxOfOrNull(selector: (T) -> R): R?
Content copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> R): R?
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.maxOfWith(comparator: Comparator<in R>, selector: (T) -> R): R
Content copied to clipboard
inline fun <R> BooleanArray.maxOfWith(comparator: Comparator<in R>, selector: (Boolean) -> R): R
Content copied to clipboard
inline fun <R> ByteArray.maxOfWith(comparator: Comparator<in R>, selector: (Byte) -> R): R
Content copied to clipboard
inline fun <R> CharArray.maxOfWith(comparator: Comparator<in R>, selector: (Char) -> R): R
Content copied to clipboard
inline fun <R> DoubleArray.maxOfWith(comparator: Comparator<in R>, selector: (Double) -> R): R
Content copied to clipboard
inline fun <R> FloatArray.maxOfWith(comparator: Comparator<in R>, selector: (Float) -> R): R
Content copied to clipboard
inline fun <R> IntArray.maxOfWith(comparator: Comparator<in R>, selector: (Int) -> R): R
Content copied to clipboard
inline fun <R> LongArray.maxOfWith(comparator: Comparator<in R>, selector: (Long) -> R): R
Content copied to clipboard
inline fun <R> ShortArray.maxOfWith(comparator: Comparator<in R>, selector: (Short) -> R): R
Content copied to clipboard
inline fun <R> UByteArray.maxOfWith(comparator: Comparator<in R>, selector: (UByte) -> R): R
Content copied to clipboard
inline fun <R> UIntArray.maxOfWith(comparator: Comparator<in R>, selector: (UInt) -> R): R
Content copied to clipboard
inline fun <R> ULongArray.maxOfWith(comparator: Comparator<in R>, selector: (ULong) -> R): R
Content copied to clipboard
inline fun <R> UShortArray.maxOfWith(comparator: Comparator<in R>, selector: (UShort) -> R): R
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?
Content copied to clipboard
inline fun <R> BooleanArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Boolean) -> R): R?
Content copied to clipboard
inline fun <R> ByteArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Byte) -> R): R?
Content copied to clipboard
inline fun <R> CharArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Char) -> R): R?
Content copied to clipboard
inline fun <R> DoubleArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Double) -> R): R?
Content copied to clipboard
inline fun <R> FloatArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Float) -> R): R?
Content copied to clipboard
inline fun <R> IntArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Int) -> R): R?
Content copied to clipboard
inline fun <R> LongArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Long) -> R): R?
Content copied to clipboard
inline fun <R> ShortArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Short) -> R): R?
Content copied to clipboard
inline fun <R> UByteArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (UByte) -> R): R?
Content copied to clipboard
inline fun <R> UIntArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (UInt) -> R): R?
Content copied to clipboard
inline fun <R> ULongArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (ULong) -> R): R?
Content copied to clipboard
inline fun <R> UShortArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (UShort) -> R): R?
Content copied to clipboard
inline fun <T, R> Iterable<T>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun BooleanArray.maxWithOrNull(comparator: Comparator<in Boolean>): Boolean?
Content copied to clipboard
fun DoubleArray.maxWithOrNull(comparator: Comparator<in Double>): Double?
Content copied to clipboard
fun UShortArray.maxWithOrNull(comparator: Comparator<in UShort>): UShort?
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.minBy(selector: (T) -> R): T
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.minBy(selector: (Boolean) -> R): Boolean
Content copied to clipboard
inline fun <R : Comparable<R>> ByteArray.minBy(selector: (Byte) -> R): Byte
Content copied to clipboard
inline fun <R : Comparable<R>> CharArray.minBy(selector: (Char) -> R): Char
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.minBy(selector: (Double) -> R): Double
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.minBy(selector: (Float) -> R): Float
Content copied to clipboard
inline fun <R : Comparable<R>> LongArray.minBy(selector: (Long) -> R): Long
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.minBy(selector: (Short) -> R): Short
Content copied to clipboard
inline fun <R : Comparable<R>> UByteArray.minBy(selector: (UByte) -> R): UByte
Content copied to clipboard
inline fun <R : Comparable<R>> UIntArray.minBy(selector: (UInt) -> R): UInt
Content copied to clipboard
inline fun <R : Comparable<R>> ULongArray.minBy(selector: (ULong) -> R): ULong
Content copied to clipboard
inline fun <R : Comparable<R>> UShortArray.minBy(selector: (UShort) -> R): UShort
Content copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.minByOrNull(selector: (T) -> R): T?
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.minByOrNull(selector: (Boolean) -> R): Boolean?
Content copied to clipboard
inline fun <R : Comparable<R>> ByteArray.minByOrNull(selector: (Byte) -> R): Byte?
Content copied to clipboard
inline fun <R : Comparable<R>> CharArray.minByOrNull(selector: (Char) -> R): Char?
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.minByOrNull(selector: (Double) -> R): Double?
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.minByOrNull(selector: (Float) -> R): Float?
Content copied to clipboard
inline fun <R : Comparable<R>> IntArray.minByOrNull(selector: (Int) -> R): Int?
Content copied to clipboard
inline fun <R : Comparable<R>> LongArray.minByOrNull(selector: (Long) -> R): Long?
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.minByOrNull(selector: (Short) -> R): Short?
Content copied to clipboard
inline fun <R : Comparable<R>> UByteArray.minByOrNull(selector: (UByte) -> R): UByte?
Content copied to clipboard
inline fun <R : Comparable<R>> UIntArray.minByOrNull(selector: (UInt) -> R): UInt?
Content copied to clipboard
inline fun <R : Comparable<R>> ULongArray.minByOrNull(selector: (ULong) -> R): ULong?
Content copied to clipboard
inline fun <R : Comparable<R>> UShortArray.minByOrNull(selector: (UShort) -> R): UShort?
Content copied to clipboard
inline fun <T, R : Comparable<R>> Iterable<T>.minByOrNull(selector: (T) -> R): T?
Content copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.minOf(selector: (T) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.minOf(selector: (Boolean) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.minOf(selector: (Double) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.minOf(selector: (Float) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.minOf(selector: (Short) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> UByteArray.minOf(selector: (UByte) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> ULongArray.minOf(selector: (ULong) -> R): R
Content copied to clipboard
inline fun <R : Comparable<R>> UShortArray.minOf(selector: (UShort) -> R): R
Content copied to clipboard
inline fun <T, R : Comparable<R>> Iterable<T>.minOf(selector: (T) -> R): R
Content copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> R): R
Content copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.minOfOrNull(selector: (T) -> R): R?
Content copied to clipboard
inline fun <T> Array<out T>.minOfOrNull(selector: (T) -> Double): Double?
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.minOfOrNull(selector: (Boolean) -> R): R?
Content copied to clipboard
inline fun BooleanArray.minOfOrNull(selector: (Boolean) -> Double): Double?
Content copied to clipboard
inline fun BooleanArray.minOfOrNull(selector: (Boolean) -> Float): Float?
Content copied to clipboard
inline fun <R : Comparable<R>> ByteArray.minOfOrNull(selector: (Byte) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> CharArray.minOfOrNull(selector: (Char) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.minOfOrNull(selector: (Double) -> R): R?
Content copied to clipboard
inline fun DoubleArray.minOfOrNull(selector: (Double) -> Double): Double?
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.minOfOrNull(selector: (Float) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> IntArray.minOfOrNull(selector: (Int) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> LongArray.minOfOrNull(selector: (Long) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.minOfOrNull(selector: (Short) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> UByteArray.minOfOrNull(selector: (UByte) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> UIntArray.minOfOrNull(selector: (UInt) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> ULongArray.minOfOrNull(selector: (ULong) -> R): R?
Content copied to clipboard
inline fun <R : Comparable<R>> UShortArray.minOfOrNull(selector: (UShort) -> R): R?
Content copied to clipboard
inline fun UShortArray.minOfOrNull(selector: (UShort) -> Double): Double?
Content copied to clipboard
inline fun <T, R : Comparable<R>> Iterable<T>.minOfOrNull(selector: (T) -> R): R?
Content copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> R): R?
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.minOfWith(comparator: Comparator<in R>, selector: (T) -> R): R
Content copied to clipboard
inline fun <R> BooleanArray.minOfWith(comparator: Comparator<in R>, selector: (Boolean) -> R): R
Content copied to clipboard
inline fun <R> ByteArray.minOfWith(comparator: Comparator<in R>, selector: (Byte) -> R): R
Content copied to clipboard
inline fun <R> CharArray.minOfWith(comparator: Comparator<in R>, selector: (Char) -> R): R
Content copied to clipboard
inline fun <R> DoubleArray.minOfWith(comparator: Comparator<in R>, selector: (Double) -> R): R
Content copied to clipboard
inline fun <R> FloatArray.minOfWith(comparator: Comparator<in R>, selector: (Float) -> R): R
Content copied to clipboard
inline fun <R> IntArray.minOfWith(comparator: Comparator<in R>, selector: (Int) -> R): R
Content copied to clipboard
inline fun <R> LongArray.minOfWith(comparator: Comparator<in R>, selector: (Long) -> R): R
Content copied to clipboard
inline fun <R> ShortArray.minOfWith(comparator: Comparator<in R>, selector: (Short) -> R): R
Content copied to clipboard
inline fun <R> UByteArray.minOfWith(comparator: Comparator<in R>, selector: (UByte) -> R): R
Content copied to clipboard
inline fun <R> UIntArray.minOfWith(comparator: Comparator<in R>, selector: (UInt) -> R): R
Content copied to clipboard
inline fun <R> ULongArray.minOfWith(comparator: Comparator<in R>, selector: (ULong) -> R): R
Content copied to clipboard
inline fun <R> UShortArray.minOfWith(comparator: Comparator<in R>, selector: (UShort) -> R): R
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.minOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?
Content copied to clipboard
inline fun <R> BooleanArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Boolean) -> R): R?
Content copied to clipboard
inline fun <R> ByteArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Byte) -> R): R?
Content copied to clipboard
inline fun <R> CharArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Char) -> R): R?
Content copied to clipboard
inline fun <R> DoubleArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Double) -> R): R?
Content copied to clipboard
inline fun <R> FloatArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Float) -> R): R?
Content copied to clipboard
inline fun <R> IntArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Int) -> R): R?
Content copied to clipboard
inline fun <R> LongArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Long) -> R): R?
Content copied to clipboard
inline fun <R> ShortArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Short) -> R): R?
Content copied to clipboard
inline fun <R> UByteArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (UByte) -> R): R?
Content copied to clipboard
inline fun <R> UIntArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (UInt) -> R): R?
Content copied to clipboard
inline fun <R> ULongArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (ULong) -> R): R?
Content copied to clipboard
inline fun <R> UShortArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (UShort) -> R): R?
Content copied to clipboard
inline fun <T, R> Iterable<T>.minOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Array<T>)
Content copied to clipboard
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Iterable<T>)
Content copied to clipboard
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Sequence<T>)
Content copied to clipboard
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Array<out K>)
Content copied to clipboard
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Iterable<K>)
Content copied to clipboard
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Sequence<K>)
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun BooleanArray.minWithOrNull(comparator: Comparator<in Boolean>): Boolean?
Content copied to clipboard
fun DoubleArray.minWithOrNull(comparator: Comparator<in Double>): Double?
Content copied to clipboard
fun UShortArray.minWithOrNull(comparator: Comparator<in UShort>): UShort?
Content copied to clipboard
Link copied to clipboard
inline fun <T> MutableList(size: Int, init: (index: Int) -> T): MutableList<T>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <K, V, M : Map<out K, V>> M.onEach(action: (Map.Entry<K, V>) -> Unit): M
Content copied to clipboard
Link copied to clipboard
inline fun <T, C : Iterable<T>> C.onEachIndexed(action: (index: Int, T) -> Unit): C
Content copied to clipboard
inline fun <K, V, M : Map<out K, V>> M.onEachIndexed(action: (index: Int, Map.Entry<K, V>) -> Unit): M
Content copied to clipboard
inline fun <T> Array<out T>.onEachIndexed(action: (index: Int, T) -> Unit): Array<out T>
Content copied to clipboard
inline fun BooleanArray.onEachIndexed(action: (index: Int, Boolean) -> Unit): BooleanArray
Content copied to clipboard
inline fun ByteArray.onEachIndexed(action: (index: Int, Byte) -> Unit): ByteArray
Content copied to clipboard
inline fun CharArray.onEachIndexed(action: (index: Int, Char) -> Unit): CharArray
Content copied to clipboard
inline fun DoubleArray.onEachIndexed(action: (index: Int, Double) -> Unit): DoubleArray
Content copied to clipboard
inline fun FloatArray.onEachIndexed(action: (index: Int, Float) -> Unit): FloatArray
Content copied to clipboard
inline fun IntArray.onEachIndexed(action: (index: Int, Int) -> Unit): IntArray
Content copied to clipboard
inline fun LongArray.onEachIndexed(action: (index: Int, Long) -> Unit): LongArray
Content copied to clipboard
inline fun ShortArray.onEachIndexed(action: (index: Int, Short) -> Unit): ShortArray
Content copied to clipboard
inline fun UByteArray.onEachIndexed(action: (index: Int, UByte) -> Unit): UByteArray
Content copied to clipboard
inline fun UIntArray.onEachIndexed(action: (index: Int, UInt) -> Unit): UIntArray
Content copied to clipboard
inline fun ULongArray.onEachIndexed(action: (index: Int, ULong) -> Unit): ULongArray
Content copied to clipboard
inline fun UShortArray.onEachIndexed(action: (index: Int, UShort) -> Unit): UShortArray
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>
Content copied to clipboard
inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean): Pair<List<Boolean>, List<Boolean>>
Content copied to clipboard
inline fun ByteArray.partition(predicate: (Byte) -> Boolean): Pair<List<Byte>, List<Byte>>
Content copied to clipboard
inline fun CharArray.partition(predicate: (Char) -> Boolean): Pair<List<Char>, List<Char>>
Content copied to clipboard
inline fun DoubleArray.partition(predicate: (Double) -> Boolean): Pair<List<Double>, List<Double>>
Content copied to clipboard
inline fun FloatArray.partition(predicate: (Float) -> Boolean): Pair<List<Float>, List<Float>>
Content copied to clipboard
inline fun IntArray.partition(predicate: (Int) -> Boolean): Pair<List<Int>, List<Int>>
Content copied to clipboard
inline fun LongArray.partition(predicate: (Long) -> Boolean): Pair<List<Long>, List<Long>>
Content copied to clipboard
Link copied to clipboard
inline operator fun <T> Array<out T>.plus(elements: Array<out T>): Array<T>
Content copied to clipboard
inline operator fun BooleanArray.plus(elements: BooleanArray): BooleanArray
Content copied to clipboard
operator fun BooleanArray.plus(elements: Collection<Boolean>): BooleanArray
Content copied to clipboard
operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>
Content copied to clipboard
operator fun <K, V> Map<out K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V>
Content copied to clipboard
Link copied to clipboard
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Array<T>)
Content copied to clipboard
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Iterable<T>)
Content copied to clipboard
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Sequence<T>)
Content copied to clipboard
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>)
Content copied to clipboard
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pair: Pair<K, V>)
Content copied to clipboard
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Iterable<Pair<K, V>>)
Content copied to clipboard
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(map: Map<K, V>)
Content copied to clipboard
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Sequence<Pair<K, V>>)
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduce(operation: (acc: S, T) -> S): S
Content copied to clipboard
inline fun BooleanArray.reduce(operation: (acc: Boolean, Boolean) -> Boolean): Boolean
Content copied to clipboard
inline fun DoubleArray.reduce(operation: (acc: Double, Double) -> Double): Double
Content copied to clipboard
inline fun FloatArray.reduce(operation: (acc: Float, Float) -> Float): Float
Content copied to clipboard
inline fun ShortArray.reduce(operation: (acc: Short, Short) -> Short): Short
Content copied to clipboard
inline fun UByteArray.reduce(operation: (acc: UByte, UByte) -> UByte): UByte
Content copied to clipboard
inline fun ULongArray.reduce(operation: (acc: ULong, ULong) -> ULong): ULong
Content copied to clipboard
inline fun UShortArray.reduce(operation: (acc: UShort, UShort) -> UShort): UShort
Content copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceIndexed(operation: (index: Int, acc: S, T) -> S): S
Content copied to clipboard
inline fun BooleanArray.reduceIndexed(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): Boolean
Content copied to clipboard
inline fun ByteArray.reduceIndexed(operation: (index: Int, acc: Byte, Byte) -> Byte): Byte
Content copied to clipboard
inline fun CharArray.reduceIndexed(operation: (index: Int, acc: Char, Char) -> Char): Char
Content copied to clipboard
inline fun DoubleArray.reduceIndexed(operation: (index: Int, acc: Double, Double) -> Double): Double
Content copied to clipboard
inline fun FloatArray.reduceIndexed(operation: (index: Int, acc: Float, Float) -> Float): Float
Content copied to clipboard
inline fun IntArray.reduceIndexed(operation: (index: Int, acc: Int, Int) -> Int): Int
Content copied to clipboard
inline fun LongArray.reduceIndexed(operation: (index: Int, acc: Long, Long) -> Long): Long
Content copied to clipboard
inline fun ShortArray.reduceIndexed(operation: (index: Int, acc: Short, Short) -> Short): Short
Content copied to clipboard
inline fun UByteArray.reduceIndexed(operation: (index: Int, acc: UByte, UByte) -> UByte): UByte
Content copied to clipboard
inline fun UIntArray.reduceIndexed(operation: (index: Int, acc: UInt, UInt) -> UInt): UInt
Content copied to clipboard
inline fun ULongArray.reduceIndexed(operation: (index: Int, acc: ULong, ULong) -> ULong): ULong
Content copied to clipboard
inline fun UShortArray.reduceIndexed(operation: (index: Int, acc: UShort, UShort) -> UShort): UShort
Content copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceIndexedOrNull(operation: (index: Int, acc: S, T) -> S): S?
Content copied to clipboard
inline fun BooleanArray.reduceIndexedOrNull(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): Boolean?
Content copied to clipboard
inline fun ByteArray.reduceIndexedOrNull(operation: (index: Int, acc: Byte, Byte) -> Byte): Byte?
Content copied to clipboard
inline fun CharArray.reduceIndexedOrNull(operation: (index: Int, acc: Char, Char) -> Char): Char?
Content copied to clipboard
inline fun DoubleArray.reduceIndexedOrNull(operation: (index: Int, acc: Double, Double) -> Double): Double?
Content copied to clipboard
inline fun FloatArray.reduceIndexedOrNull(operation: (index: Int, acc: Float, Float) -> Float): Float?
Content copied to clipboard
inline fun IntArray.reduceIndexedOrNull(operation: (index: Int, acc: Int, Int) -> Int): Int?
Content copied to clipboard
inline fun LongArray.reduceIndexedOrNull(operation: (index: Int, acc: Long, Long) -> Long): Long?
Content copied to clipboard
inline fun ShortArray.reduceIndexedOrNull(operation: (index: Int, acc: Short, Short) -> Short): Short?
Content copied to clipboard
inline fun UByteArray.reduceIndexedOrNull(operation: (index: Int, acc: UByte, UByte) -> UByte): UByte?
Content copied to clipboard
inline fun UIntArray.reduceIndexedOrNull(operation: (index: Int, acc: UInt, UInt) -> UInt): UInt?
Content copied to clipboard
inline fun ULongArray.reduceIndexedOrNull(operation: (index: Int, acc: ULong, ULong) -> ULong): ULong?
Content copied to clipboard
inline fun UShortArray.reduceIndexedOrNull(operation: (index: Int, acc: UShort, UShort) -> UShort): UShort?
Content copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceOrNull(operation: (acc: S, T) -> S): S?
Content copied to clipboard
inline fun BooleanArray.reduceOrNull(operation: (acc: Boolean, Boolean) -> Boolean): Boolean?
Content copied to clipboard
inline fun ByteArray.reduceOrNull(operation: (acc: Byte, Byte) -> Byte): Byte?
Content copied to clipboard
inline fun CharArray.reduceOrNull(operation: (acc: Char, Char) -> Char): Char?
Content copied to clipboard
inline fun DoubleArray.reduceOrNull(operation: (acc: Double, Double) -> Double): Double?
Content copied to clipboard
inline fun FloatArray.reduceOrNull(operation: (acc: Float, Float) -> Float): Float?
Content copied to clipboard
inline fun IntArray.reduceOrNull(operation: (acc: Int, Int) -> Int): Int?
Content copied to clipboard
inline fun LongArray.reduceOrNull(operation: (acc: Long, Long) -> Long): Long?
Content copied to clipboard
inline fun ShortArray.reduceOrNull(operation: (acc: Short, Short) -> Short): Short?
Content copied to clipboard
inline fun UByteArray.reduceOrNull(operation: (acc: UByte, UByte) -> UByte): UByte?
Content copied to clipboard
inline fun UIntArray.reduceOrNull(operation: (acc: UInt, UInt) -> UInt): UInt?
Content copied to clipboard
inline fun ULongArray.reduceOrNull(operation: (acc: ULong, ULong) -> ULong): ULong?
Content copied to clipboard
inline fun UShortArray.reduceOrNull(operation: (acc: UShort, UShort) -> UShort): UShort?
Content copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRight(operation: (T, acc: S) -> S): S
Content copied to clipboard
inline fun BooleanArray.reduceRight(operation: (Boolean, acc: Boolean) -> Boolean): Boolean
Content copied to clipboard
inline fun ByteArray.reduceRight(operation: (Byte, acc: Byte) -> Byte): Byte
Content copied to clipboard
inline fun CharArray.reduceRight(operation: (Char, acc: Char) -> Char): Char
Content copied to clipboard
inline fun DoubleArray.reduceRight(operation: (Double, acc: Double) -> Double): Double
Content copied to clipboard
inline fun FloatArray.reduceRight(operation: (Float, acc: Float) -> Float): Float
Content copied to clipboard
inline fun LongArray.reduceRight(operation: (Long, acc: Long) -> Long): Long
Content copied to clipboard
inline fun ShortArray.reduceRight(operation: (Short, acc: Short) -> Short): Short
Content copied to clipboard
inline fun UByteArray.reduceRight(operation: (UByte, acc: UByte) -> UByte): UByte
Content copied to clipboard
inline fun UIntArray.reduceRight(operation: (UInt, acc: UInt) -> UInt): UInt
Content copied to clipboard
inline fun ULongArray.reduceRight(operation: (ULong, acc: ULong) -> ULong): ULong
Content copied to clipboard
inline fun UShortArray.reduceRight(operation: (UShort, acc: UShort) -> UShort): UShort
Content copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S
Content copied to clipboard
inline fun BooleanArray.reduceRightIndexed(operation: (index: Int, Boolean, acc: Boolean) -> Boolean): Boolean
Content copied to clipboard
inline fun ByteArray.reduceRightIndexed(operation: (index: Int, Byte, acc: Byte) -> Byte): Byte
Content copied to clipboard
inline fun CharArray.reduceRightIndexed(operation: (index: Int, Char, acc: Char) -> Char): Char
Content copied to clipboard
inline fun DoubleArray.reduceRightIndexed(operation: (index: Int, Double, acc: Double) -> Double): Double
Content copied to clipboard
inline fun FloatArray.reduceRightIndexed(operation: (index: Int, Float, acc: Float) -> Float): Float
Content copied to clipboard
inline fun IntArray.reduceRightIndexed(operation: (index: Int, Int, acc: Int) -> Int): Int
Content copied to clipboard
inline fun LongArray.reduceRightIndexed(operation: (index: Int, Long, acc: Long) -> Long): Long
Content copied to clipboard
inline fun ShortArray.reduceRightIndexed(operation: (index: Int, Short, acc: Short) -> Short): Short
Content copied to clipboard
inline fun UByteArray.reduceRightIndexed(operation: (index: Int, UByte, acc: UByte) -> UByte): UByte
Content copied to clipboard
inline fun UIntArray.reduceRightIndexed(operation: (index: Int, UInt, acc: UInt) -> UInt): UInt
Content copied to clipboard
inline fun ULongArray.reduceRightIndexed(operation: (index: Int, ULong, acc: ULong) -> ULong): ULong
Content copied to clipboard
inline fun UShortArray.reduceRightIndexed(operation: (index: Int, UShort, acc: UShort) -> UShort): UShort
Content copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRightIndexedOrNull(operation: (index: Int, T, acc: S) -> S): S?
Content copied to clipboard
inline fun BooleanArray.reduceRightIndexedOrNull(operation: (index: Int, Boolean, acc: Boolean) -> Boolean): Boolean?
Content copied to clipboard
inline fun ByteArray.reduceRightIndexedOrNull(operation: (index: Int, Byte, acc: Byte) -> Byte): Byte?
Content copied to clipboard
inline fun CharArray.reduceRightIndexedOrNull(operation: (index: Int, Char, acc: Char) -> Char): Char?
Content copied to clipboard
inline fun DoubleArray.reduceRightIndexedOrNull(operation: (index: Int, Double, acc: Double) -> Double): Double?
Content copied to clipboard
inline fun FloatArray.reduceRightIndexedOrNull(operation: (index: Int, Float, acc: Float) -> Float): Float?
Content copied to clipboard
inline fun IntArray.reduceRightIndexedOrNull(operation: (index: Int, Int, acc: Int) -> Int): Int?
Content copied to clipboard
inline fun LongArray.reduceRightIndexedOrNull(operation: (index: Int, Long, acc: Long) -> Long): Long?
Content copied to clipboard
inline fun ShortArray.reduceRightIndexedOrNull(operation: (index: Int, Short, acc: Short) -> Short): Short?
Content copied to clipboard
inline fun UByteArray.reduceRightIndexedOrNull(operation: (index: Int, UByte, acc: UByte) -> UByte): UByte?
Content copied to clipboard
inline fun UIntArray.reduceRightIndexedOrNull(operation: (index: Int, UInt, acc: UInt) -> UInt): UInt?
Content copied to clipboard
inline fun ULongArray.reduceRightIndexedOrNull(operation: (index: Int, ULong, acc: ULong) -> ULong): ULong?
Content copied to clipboard
inline fun UShortArray.reduceRightIndexedOrNull(operation: (index: Int, UShort, acc: UShort) -> UShort): UShort?
Content copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRightOrNull(operation: (T, acc: S) -> S): S?
Content copied to clipboard
inline fun BooleanArray.reduceRightOrNull(operation: (Boolean, acc: Boolean) -> Boolean): Boolean?
Content copied to clipboard
inline fun ByteArray.reduceRightOrNull(operation: (Byte, acc: Byte) -> Byte): Byte?
Content copied to clipboard
inline fun CharArray.reduceRightOrNull(operation: (Char, acc: Char) -> Char): Char?
Content copied to clipboard
inline fun DoubleArray.reduceRightOrNull(operation: (Double, acc: Double) -> Double): Double?
Content copied to clipboard
inline fun FloatArray.reduceRightOrNull(operation: (Float, acc: Float) -> Float): Float?
Content copied to clipboard
inline fun IntArray.reduceRightOrNull(operation: (Int, acc: Int) -> Int): Int?
Content copied to clipboard
inline fun LongArray.reduceRightOrNull(operation: (Long, acc: Long) -> Long): Long?
Content copied to clipboard
inline fun ShortArray.reduceRightOrNull(operation: (Short, acc: Short) -> Short): Short?
Content copied to clipboard
inline fun UByteArray.reduceRightOrNull(operation: (UByte, acc: UByte) -> UByte): UByte?
Content copied to clipboard
inline fun UIntArray.reduceRightOrNull(operation: (UInt, acc: UInt) -> UInt): UInt?
Content copied to clipboard
inline fun ULongArray.reduceRightOrNull(operation: (ULong, acc: ULong) -> ULong): ULong?
Content copied to clipboard
inline fun UShortArray.reduceRightOrNull(operation: (UShort, acc: UShort) -> UShort): UShort?
Content copied to clipboard
Link copied to clipboard
fun <T> MutableCollection<in T>.removeAll(elements: Array<out T>): Boolean
Content copied to clipboard
inline fun <T> MutableCollection<out T>.removeAll(elements: Collection<T>): Boolean
Content copied to clipboard
fun <T> MutableCollection<in T>.removeAll(elements: Iterable<T>): Boolean
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <T> MutableCollection<in T>.retainAll(elements: Array<out T>): Boolean
Content copied to clipboard
inline fun <T> MutableCollection<out T>.retainAll(elements: Collection<T>): Boolean
Content copied to clipboard
fun <T> MutableCollection<in T>.retainAll(elements: Iterable<T>): Boolean
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.runningFold(initial: R, operation: (acc: R, T) -> R): List<R>
Content copied to clipboard
inline fun <R> BooleanArray.runningFold(initial: R, operation: (acc: R, Boolean) -> R): List<R>
Content copied to clipboard
inline fun <R> ByteArray.runningFold(initial: R, operation: (acc: R, Byte) -> R): List<R>
Content copied to clipboard
inline fun <R> CharArray.runningFold(initial: R, operation: (acc: R, Char) -> R): List<R>
Content copied to clipboard
inline fun <R> DoubleArray.runningFold(initial: R, operation: (acc: R, Double) -> R): List<R>
Content copied to clipboard
inline fun <R> FloatArray.runningFold(initial: R, operation: (acc: R, Float) -> R): List<R>
Content copied to clipboard
inline fun <R> IntArray.runningFold(initial: R, operation: (acc: R, Int) -> R): List<R>
Content copied to clipboard
inline fun <R> LongArray.runningFold(initial: R, operation: (acc: R, Long) -> R): List<R>
Content copied to clipboard
inline fun <R> ShortArray.runningFold(initial: R, operation: (acc: R, Short) -> R): List<R>
Content copied to clipboard
inline fun <R> UByteArray.runningFold(initial: R, operation: (acc: R, UByte) -> R): List<R>
Content copied to clipboard
inline fun <R> UIntArray.runningFold(initial: R, operation: (acc: R, UInt) -> R): List<R>
Content copied to clipboard
inline fun <R> ULongArray.runningFold(initial: R, operation: (acc: R, ULong) -> R): List<R>
Content copied to clipboard
inline fun <R> UShortArray.runningFold(initial: R, operation: (acc: R, UShort) -> R): List<R>
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>
Content copied to clipboard
inline fun <R> BooleanArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): List<R>
Content copied to clipboard
inline fun <R> ByteArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): List<R>
Content copied to clipboard
inline fun <R> CharArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): List<R>
Content copied to clipboard
inline fun <R> DoubleArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): List<R>
Content copied to clipboard
inline fun <R> FloatArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): List<R>
Content copied to clipboard
inline fun <R> IntArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): List<R>
Content copied to clipboard
inline fun <R> LongArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): List<R>
Content copied to clipboard
inline fun <R> ShortArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): List<R>
Content copied to clipboard
inline fun <R> UByteArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, UByte) -> R): List<R>
Content copied to clipboard
inline fun <R> UIntArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, UInt) -> R): List<R>
Content copied to clipboard
inline fun <R> ULongArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, ULong) -> R): List<R>
Content copied to clipboard
inline fun <R> UShortArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, UShort) -> R): List<R>
Content copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.runningReduce(operation: (acc: S, T) -> S): List<S>
Content copied to clipboard
inline fun BooleanArray.runningReduce(operation: (acc: Boolean, Boolean) -> Boolean): List<Boolean>
Content copied to clipboard
inline fun ByteArray.runningReduce(operation: (acc: Byte, Byte) -> Byte): List<Byte>
Content copied to clipboard
inline fun CharArray.runningReduce(operation: (acc: Char, Char) -> Char): List<Char>
Content copied to clipboard
inline fun DoubleArray.runningReduce(operation: (acc: Double, Double) -> Double): List<Double>
Content copied to clipboard
inline fun FloatArray.runningReduce(operation: (acc: Float, Float) -> Float): List<Float>
Content copied to clipboard
inline fun IntArray.runningReduce(operation: (acc: Int, Int) -> Int): List<Int>
Content copied to clipboard
inline fun LongArray.runningReduce(operation: (acc: Long, Long) -> Long): List<Long>
Content copied to clipboard
inline fun ShortArray.runningReduce(operation: (acc: Short, Short) -> Short): List<Short>
Content copied to clipboard
inline fun UByteArray.runningReduce(operation: (acc: UByte, UByte) -> UByte): List<UByte>
Content copied to clipboard
inline fun UIntArray.runningReduce(operation: (acc: UInt, UInt) -> UInt): List<UInt>
Content copied to clipboard
inline fun ULongArray.runningReduce(operation: (acc: ULong, ULong) -> ULong): List<ULong>
Content copied to clipboard
inline fun UShortArray.runningReduce(operation: (acc: UShort, UShort) -> UShort): List<UShort>
Content copied to clipboard
Link copied to clipboard
inline fun <S, T : S> Array<out T>.runningReduceIndexed(operation: (index: Int, acc: S, T) -> S): List<S>
Content copied to clipboard
inline fun BooleanArray.runningReduceIndexed(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): List<Boolean>
Content copied to clipboard
inline fun ByteArray.runningReduceIndexed(operation: (index: Int, acc: Byte, Byte) -> Byte): List<Byte>
Content copied to clipboard
inline fun CharArray.runningReduceIndexed(operation: (index: Int, acc: Char, Char) -> Char): List<Char>
Content copied to clipboard
inline fun DoubleArray.runningReduceIndexed(operation: (index: Int, acc: Double, Double) -> Double): List<Double>
Content copied to clipboard
inline fun FloatArray.runningReduceIndexed(operation: (index: Int, acc: Float, Float) -> Float): List<Float>
Content copied to clipboard
inline fun IntArray.runningReduceIndexed(operation: (index: Int, acc: Int, Int) -> Int): List<Int>
Content copied to clipboard
inline fun LongArray.runningReduceIndexed(operation: (index: Int, acc: Long, Long) -> Long): List<Long>
Content copied to clipboard
inline fun ShortArray.runningReduceIndexed(operation: (index: Int, acc: Short, Short) -> Short): List<Short>
Content copied to clipboard
inline fun UByteArray.runningReduceIndexed(operation: (index: Int, acc: UByte, UByte) -> UByte): List<UByte>
Content copied to clipboard
inline fun UIntArray.runningReduceIndexed(operation: (index: Int, acc: UInt, UInt) -> UInt): List<UInt>
Content copied to clipboard
inline fun ULongArray.runningReduceIndexed(operation: (index: Int, acc: ULong, ULong) -> ULong): List<ULong>
Content copied to clipboard
inline fun UShortArray.runningReduceIndexed(operation: (index: Int, acc: UShort, UShort) -> UShort): List<UShort>
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.scan(initial: R, operation: (acc: R, T) -> R): List<R>
Content copied to clipboard
inline fun <R> BooleanArray.scan(initial: R, operation: (acc: R, Boolean) -> R): List<R>
Content copied to clipboard
inline fun <R> ByteArray.scan(initial: R, operation: (acc: R, Byte) -> R): List<R>
Content copied to clipboard
inline fun <R> CharArray.scan(initial: R, operation: (acc: R, Char) -> R): List<R>
Content copied to clipboard
inline fun <R> DoubleArray.scan(initial: R, operation: (acc: R, Double) -> R): List<R>
Content copied to clipboard
inline fun <R> FloatArray.scan(initial: R, operation: (acc: R, Float) -> R): List<R>
Content copied to clipboard
inline fun <R> IntArray.scan(initial: R, operation: (acc: R, Int) -> R): List<R>
Content copied to clipboard
inline fun <R> LongArray.scan(initial: R, operation: (acc: R, Long) -> R): List<R>
Content copied to clipboard
inline fun <R> ShortArray.scan(initial: R, operation: (acc: R, Short) -> R): List<R>
Content copied to clipboard
inline fun <R> UByteArray.scan(initial: R, operation: (acc: R, UByte) -> R): List<R>
Content copied to clipboard
inline fun <R> UIntArray.scan(initial: R, operation: (acc: R, UInt) -> R): List<R>
Content copied to clipboard
inline fun <R> ULongArray.scan(initial: R, operation: (acc: R, ULong) -> R): List<R>
Content copied to clipboard
Link copied to clipboard
inline fun <T, R> Array<out T>.scanIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>
Content copied to clipboard
inline fun <R> BooleanArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): List<R>
Content copied to clipboard
inline fun <R> ByteArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): List<R>
Content copied to clipboard
inline fun <R> CharArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): List<R>
Content copied to clipboard
inline fun <R> DoubleArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): List<R>
Content copied to clipboard
inline fun <R> FloatArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): List<R>
Content copied to clipboard
inline fun <R> IntArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): List<R>
Content copied to clipboard
inline fun <R> LongArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): List<R>
Content copied to clipboard
inline fun <R> ShortArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): List<R>
Content copied to clipboard
inline fun <R> UByteArray.scanIndexed(initial: R, operation: (index: Int, acc: R, UByte) -> R): List<R>
Content copied to clipboard
inline fun <R> UIntArray.scanIndexed(initial: R, operation: (index: Int, acc: R, UInt) -> R): List<R>
Content copied to clipboard
inline fun <R> ULongArray.scanIndexed(initial: R, operation: (index: Int, acc: R, ULong) -> R): List<R>
Content copied to clipboard
inline fun <R> UShortArray.scanIndexed(initial: R, operation: (index: Int, acc: R, UShort) -> R): List<R>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun BooleanArray.singleOrNull(predicate: (Boolean) -> Boolean): Boolean?
Content copied to clipboard
inline fun DoubleArray.singleOrNull(predicate: (Double) -> Boolean): Double?
Content copied to clipboard
inline fun FloatArray.singleOrNull(predicate: (Float) -> Boolean): Float?
Content copied to clipboard
inline fun ShortArray.singleOrNull(predicate: (Short) -> Boolean): Short?
Content copied to clipboard
inline fun UByteArray.singleOrNull(predicate: (UByte) -> Boolean): UByte?
Content copied to clipboard
inline fun ULongArray.singleOrNull(predicate: (ULong) -> Boolean): ULong?
Content copied to clipboard
inline fun UShortArray.singleOrNull(predicate: (UShort) -> Boolean): UShort?
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Content copied to clipboard
Content copied to clipboard
Content copied to clipboard
Content copied to clipboard
Content copied to clipboard
Content copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortByDescending(crossinline selector: (T) -> R?)
Content copied to clipboard
inline fun <T, R : Comparable<R>> MutableList<T>.sortByDescending(crossinline selector: (T) -> R?)
Content copied to clipboard
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.sortDescending(fromIndex: Int, toIndex: Int)
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <T> Array<out T>.sortedArrayWith(comparator: Comparator<in T>): Array<out T>
Content copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortedBy(crossinline selector: (T) -> R?): List<T>
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.sortedBy(crossinline selector: (Boolean) -> R?): List<Boolean>
Content copied to clipboard
inline fun <R : Comparable<R>> ByteArray.sortedBy(crossinline selector: (Byte) -> R?): List<Byte>
Content copied to clipboard
inline fun <R : Comparable<R>> CharArray.sortedBy(crossinline selector: (Char) -> R?): List<Char>
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.sortedBy(crossinline selector: (Double) -> R?): List<Double>
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.sortedBy(crossinline selector: (Float) -> R?): List<Float>
Content copied to clipboard
inline fun <R : Comparable<R>> IntArray.sortedBy(crossinline selector: (Int) -> R?): List<Int>
Content copied to clipboard
inline fun <R : Comparable<R>> LongArray.sortedBy(crossinline selector: (Long) -> R?): List<Long>
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.sortedBy(crossinline selector: (Short) -> R?): List<Short>
Content copied to clipboard
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortedByDescending(crossinline selector: (T) -> R?): List<T>
Content copied to clipboard
inline fun <R : Comparable<R>> BooleanArray.sortedByDescending(crossinline selector: (Boolean) -> R?): List<Boolean>
Content copied to clipboard
inline fun <R : Comparable<R>> ByteArray.sortedByDescending(crossinline selector: (Byte) -> R?): List<Byte>
Content copied to clipboard
inline fun <R : Comparable<R>> CharArray.sortedByDescending(crossinline selector: (Char) -> R?): List<Char>
Content copied to clipboard
inline fun <R : Comparable<R>> DoubleArray.sortedByDescending(crossinline selector: (Double) -> R?): List<Double>
Content copied to clipboard
inline fun <R : Comparable<R>> FloatArray.sortedByDescending(crossinline selector: (Float) -> R?): List<Float>
Content copied to clipboard
inline fun <R : Comparable<R>> IntArray.sortedByDescending(crossinline selector: (Int) -> R?): List<Int>
Content copied to clipboard
inline fun <R : Comparable<R>> LongArray.sortedByDescending(crossinline selector: (Long) -> R?): List<Long>
Content copied to clipboard
inline fun <R : Comparable<R>> ShortArray.sortedByDescending(crossinline selector: (Short) -> R?): List<Short>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun BooleanArray.sortedWith(comparator: Comparator<in Boolean>): List<Boolean>
Content copied to clipboard
fun DoubleArray.sortedWith(comparator: Comparator<in Double>): List<Double>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.takeLastWhile(predicate: (T) -> Boolean): List<T>
Content copied to clipboard
inline fun BooleanArray.takeLastWhile(predicate: (Boolean) -> Boolean): List<Boolean>
Content copied to clipboard
inline fun ByteArray.takeLastWhile(predicate: (Byte) -> Boolean): List<Byte>
Content copied to clipboard
inline fun CharArray.takeLastWhile(predicate: (Char) -> Boolean): List<Char>
Content copied to clipboard
inline fun DoubleArray.takeLastWhile(predicate: (Double) -> Boolean): List<Double>
Content copied to clipboard
inline fun FloatArray.takeLastWhile(predicate: (Float) -> Boolean): List<Float>
Content copied to clipboard
inline fun IntArray.takeLastWhile(predicate: (Int) -> Boolean): List<Int>
Content copied to clipboard
inline fun LongArray.takeLastWhile(predicate: (Long) -> Boolean): List<Long>
Content copied to clipboard
inline fun ShortArray.takeLastWhile(predicate: (Short) -> Boolean): List<Short>
Content copied to clipboard
inline fun UByteArray.takeLastWhile(predicate: (UByte) -> Boolean): List<UByte>
Content copied to clipboard
inline fun UIntArray.takeLastWhile(predicate: (UInt) -> Boolean): List<UInt>
Content copied to clipboard
inline fun ULongArray.takeLastWhile(predicate: (ULong) -> Boolean): List<ULong>
Content copied to clipboard
inline fun UShortArray.takeLastWhile(predicate: (UShort) -> Boolean): List<UShort>
Content copied to clipboard
Link copied to clipboard
inline fun <T> Array<out T>.takeWhile(predicate: (T) -> Boolean): List<T>
Content copied to clipboard
inline fun BooleanArray.takeWhile(predicate: (Boolean) -> Boolean): List<Boolean>
Content copied to clipboard
inline fun DoubleArray.takeWhile(predicate: (Double) -> Boolean): List<Double>
Content copied to clipboard
inline fun FloatArray.takeWhile(predicate: (Float) -> Boolean): List<Float>
Content copied to clipboard
inline fun ShortArray.takeWhile(predicate: (Short) -> Boolean): List<Short>
Content copied to clipboard
inline fun UByteArray.takeWhile(predicate: (UByte) -> Boolean): List<UByte>
Content copied to clipboard
inline fun ULongArray.takeWhile(predicate: (ULong) -> Boolean): List<ULong>
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(destination: C): C
Content copied to clipboard
fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection(destination: C): C
Content copied to clipboard
fun <C : MutableCollection<in Byte>> ByteArray.toCollection(destination: C): C
Content copied to clipboard
fun <C : MutableCollection<in Char>> CharArray.toCollection(destination: C): C
Content copied to clipboard
fun <C : MutableCollection<in Double>> DoubleArray.toCollection(destination: C): C
Content copied to clipboard
fun <C : MutableCollection<in Float>> FloatArray.toCollection(destination: C): C
Content copied to clipboard
fun <C : MutableCollection<in Int>> IntArray.toCollection(destination: C): C
Content copied to clipboard
fun <C : MutableCollection<in Long>> LongArray.toCollection(destination: C): C
Content copied to clipboard
fun <C : MutableCollection<in Short>> ShortArray.toCollection(destination: C): C
Content copied to clipboard
fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(destination: C): C
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <K, V, M : MutableMap<in K, in V>> Array<out Pair<K, V>>.toMap(destination: M): M
Content copied to clipboard
fun <K, V, M : MutableMap<in K, in V>> Iterable<Pair<K, V>>.toMap(destination: M): M
Content copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
infix fun <R> BooleanArray.zip(other: Array<out R>): List<Pair<Boolean, R>>
Content copied to clipboard
infix fun BooleanArray.zip(other: BooleanArray): List<Pair<Boolean, Boolean>>
Content copied to clipboard
infix fun <R> BooleanArray.zip(other: Iterable<R>): List<Pair<Boolean, R>>
Content copied to clipboard
infix fun <R> DoubleArray.zip(other: Array<out R>): List<Pair<Double, R>>
Content copied to clipboard
infix fun DoubleArray.zip(other: DoubleArray): List<Pair<Double, Double>>
Content copied to clipboard
infix fun <R> UShortArray.zip(other: Array<out R>): List<Pair<UShort, R>>
Content copied to clipboard
infix fun UShortArray.zip(other: UShortArray): List<Pair<UShort, UShort>>
Content copied to clipboard
inline fun <T, R, V> Array<out T>.zip(other: Array<out R>, transform: (a: T, b: R) -> V): List<V>
Content copied to clipboard
inline fun <T, R, V> Array<out T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> BooleanArray.zip(other: Array<out R>, transform: (a: Boolean, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> BooleanArray.zip(other: BooleanArray, transform: (a: Boolean, b: Boolean) -> V): List<V>
Content copied to clipboard
inline fun <R, V> BooleanArray.zip(other: Iterable<R>, transform: (a: Boolean, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> ByteArray.zip(other: Array<out R>, transform: (a: Byte, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> ByteArray.zip(other: ByteArray, transform: (a: Byte, b: Byte) -> V): List<V>
Content copied to clipboard
inline fun <R, V> ByteArray.zip(other: Iterable<R>, transform: (a: Byte, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> CharArray.zip(other: Array<out R>, transform: (a: Char, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> CharArray.zip(other: CharArray, transform: (a: Char, b: Char) -> V): List<V>
Content copied to clipboard
inline fun <R, V> CharArray.zip(other: Iterable<R>, transform: (a: Char, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> DoubleArray.zip(other: Array<out R>, transform: (a: Double, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> DoubleArray.zip(other: DoubleArray, transform: (a: Double, b: Double) -> V): List<V>
Content copied to clipboard
inline fun <R, V> DoubleArray.zip(other: Iterable<R>, transform: (a: Double, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> FloatArray.zip(other: Array<out R>, transform: (a: Float, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> FloatArray.zip(other: FloatArray, transform: (a: Float, b: Float) -> V): List<V>
Content copied to clipboard
inline fun <R, V> FloatArray.zip(other: Iterable<R>, transform: (a: Float, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> IntArray.zip(other: Array<out R>, transform: (a: Int, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> IntArray.zip(other: IntArray, transform: (a: Int, b: Int) -> V): List<V>
Content copied to clipboard
inline fun <R, V> IntArray.zip(other: Iterable<R>, transform: (a: Int, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> LongArray.zip(other: Array<out R>, transform: (a: Long, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> LongArray.zip(other: LongArray, transform: (a: Long, b: Long) -> V): List<V>
Content copied to clipboard
inline fun <R, V> LongArray.zip(other: Iterable<R>, transform: (a: Long, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> ShortArray.zip(other: Array<out R>, transform: (a: Short, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> ShortArray.zip(other: ShortArray, transform: (a: Short, b: Short) -> V): List<V>
Content copied to clipboard
inline fun <R, V> ShortArray.zip(other: Iterable<R>, transform: (a: Short, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> UByteArray.zip(other: Array<out R>, transform: (a: UByte, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> UByteArray.zip(other: UByteArray, transform: (a: UByte, b: UByte) -> V): List<V>
Content copied to clipboard
inline fun <R, V> UByteArray.zip(other: Iterable<R>, transform: (a: UByte, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> UIntArray.zip(other: Array<out R>, transform: (a: UInt, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> UIntArray.zip(other: UIntArray, transform: (a: UInt, b: UInt) -> V): List<V>
Content copied to clipboard
inline fun <R, V> UIntArray.zip(other: Iterable<R>, transform: (a: UInt, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> ULongArray.zip(other: Array<out R>, transform: (a: ULong, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> ULongArray.zip(other: ULongArray, transform: (a: ULong, b: ULong) -> V): List<V>
Content copied to clipboard
inline fun <R, V> ULongArray.zip(other: Iterable<R>, transform: (a: ULong, b: R) -> V): List<V>
Content copied to clipboard
inline fun <R, V> UShortArray.zip(other: Array<out R>, transform: (a: UShort, b: R) -> V): List<V>
Content copied to clipboard
inline fun <V> UShortArray.zip(other: UShortArray, transform: (a: UShort, b: UShort) -> V): List<V>
Content copied to clipboard
inline fun <R, V> UShortArray.zip(other: Iterable<R>, transform: (a: UShort, b: R) -> V): List<V>
Content copied to clipboard